package net.qiqbframework.messaging.annotation;

import net.qiqbframework.common.resolving.ResolvedAttributes;
import net.qiqbframework.messaging.Message;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.validation.constraints.NotNull;
import java.lang.annotation.Annotation;
import java.lang.reflect.Executable;
import java.lang.reflect.Member;
import java.util.Map;
import java.util.Optional;

/**
 * 定义处理特定消息的处理成员。
 */
public interface MessageExecutableHandler {
    /**
     * 在执行handler 之前，会通过此方法进行判断是否可以执行。
     *
     * @return false:将不执行 {@link MessageExecutableHandler#handle(Message, Object)} 方法。true：执行
     */
    boolean canHandle(@Nonnull Message<?> message);

    /**
     * 调用target 对象方法来具体处理逻辑
     */
    Object handle(@Nonnull Message<?> message, @Nullable Object target) throws Exception;


    /**
     * 获取待执行消息的实际负载对象类型
     */
    Class<?> payloadType();

    /**
     * 多个 Handler 的情况下，优先级，越小越优先。
     */
    default int priority() {
        return 0;
    }

    Optional<Map<String, Object>> annotationAttributes(Class<? extends Annotation> annotationType);

    /**
     * 返回期望类型的对象
     */
    <EH> Optional<EH> unwrap(Class<EH> handlerType);


    default Class<?> declaringClass() {
        return unwrap(Member.class).map(Member::getDeclaringClass)
                .orElseThrow(() -> new UnsupportedOperationException(
                        "This implementation of MessageHandlingMember does not wrap a "
                                + "java.lang.reflect.Member. Please provide a different way of "
                                + "getting 'declaringClass' of this MessageHandlingMember."));
    }


    default String signature() {
        return unwrap(Executable.class).map(Executable::toGenericString)
                .orElse("__unknown__");
    }

    /**
     * 获取 attributeKey 属性，如果为空，返回 Optional.empty()
     */
    default <R> Optional<R> attribute(String attributeKey) {
        return Optional.empty();
    }

    @NotNull
    ResolvedAttributes attributes();

}
